import { defineStore } from 'pinia'
import { useDatasetStore } from './dataset.js'

export const useConversationStore = defineStore('conversation', {
  state: () => ({
    // 当前选中的对话索引
    currentConversationIndex: -1,
    
    // 当前编辑的消息
    editingMessage: null,
    
    // 消息编辑器状态
    messageEditor: {
      isVisible: false,
      messageIndex: -1,
      isNewMessage: false
    },

    // 组件级编辑状态（从 ConversationEditor 组件移到这里）
    componentEditingState: {
      editingMessageIndex: -1,
      editingMessage: null
    },

    // 支持的角色类型
    roleTypes: [
      { value: 'human', label: '用户输入', color: '#409EFF', icon: 'user' },
      { value: 'thinking', label: 'AI思考', color: '#909399', icon: 'brain' },
      { value: 'function_call', label: '函数调用', color: '#E6A23C', icon: 'function' },
      { value: 'observation', label: '执行结果', color: '#67C23A', icon: 'eye' },
      { value: 'gpt', label: 'AI回复', color: '#F56C6C', icon: 'robot' }
    ],

    // 验证规则缓存
    validationCache: new Map()
  }),

  getters: {
    // 获取当前对话
    currentConversation: (state) => {
      const datasetStore = useDatasetStore()
      if (state.currentConversationIndex >= 0 && 
          state.currentConversationIndex < datasetStore.currentDataset.data.length) {
        return datasetStore.currentDataset.data[state.currentConversationIndex]
      }
      return null
    },

    // 获取当前对话的消息列表
    currentMessages: (state) => {
      const conversation = state.currentConversation
      return conversation?.conversations || []
    },

    // 验证当前对话是否符合规则
    currentConversationValidation: (state) => {
      const conversation = state.currentConversation
      if (!conversation) return { isValid: true, errors: [] }
      
      return state.validateConversationStructure(conversation.conversations || [])
    },

    // 根据角色值获取角色信息
    getRoleInfo: (state) => (roleValue) => {
      return state.roleTypes.find(role => role.value === roleValue) || 
             { value: roleValue, label: roleValue, color: '#909399', icon: 'question' }
    }
  },

  actions: {
    // 选择对话
    selectConversation(index) {
      // 在切换对话之前，先自动保存正在编辑的消息
      const autoSaved = this.autoSaveEditingMessage()
      
      this.currentConversationIndex = index
      this.closeMessageEditor()
      
      // 清除编辑状态
      this.clearComponentEditingState()
      
      // 如果自动保存成功，显示提示
      if (autoSaved) {
        // 我们需要在组件中处理这个提示，因为 store 中不能直接调用 ElMessage
        return { autoSaved: true }
      }
      
      return { autoSaved: false }
    },

    // 添加消息到当前对话
    addMessage(role = 'human', value = '', insertIndex = -1) {
      const datasetStore = useDatasetStore()
      const conversation = this.currentConversation
      
      if (!conversation) return false

      const newMessage = { from: role, value }
      
      if (insertIndex >= 0 && insertIndex <= conversation.conversations.length) {
        conversation.conversations.splice(insertIndex, 0, newMessage)
      } else {
        conversation.conversations.push(newMessage)
      }
      
      datasetStore.markAsModified()
      return true
    },

    // 删除消息
    removeMessage(messageIndex) {
      const datasetStore = useDatasetStore()
      const conversation = this.currentConversation
      
      if (!conversation || messageIndex < 0 || messageIndex >= conversation.conversations.length) {
        return false
      }

      conversation.conversations.splice(messageIndex, 1)
      datasetStore.markAsModified()
      
      // 如果删除的是正在编辑的消息，关闭编辑器
      if (this.messageEditor.messageIndex === messageIndex) {
        this.closeMessageEditor()
      }
      
      return true
    },

    // 更新消息
    updateMessage(messageIndex, updates) {
      const datasetStore = useDatasetStore()
      const conversation = this.currentConversation
      
      if (!conversation || messageIndex < 0 || messageIndex >= conversation.conversations.length) {
        return false
      }

      conversation.conversations[messageIndex] = {
        ...conversation.conversations[messageIndex],
        ...updates
      }
      
      datasetStore.markAsModified()
      return true
    },

    // 移动消息位置
    moveMessage(fromIndex, toIndex) {
      const conversation = this.currentConversation
      if (!conversation || fromIndex === toIndex) return false

      const messages = conversation.conversations
      if (fromIndex < 0 || fromIndex >= messages.length || 
          toIndex < 0 || toIndex >= messages.length) {
        return false
      }

      const [movedMessage] = messages.splice(fromIndex, 1)
      messages.splice(toIndex, 0, movedMessage)
      
      const datasetStore = useDatasetStore()
      datasetStore.markAsModified()
      return true
    },

    // 打开消息编辑器
    openMessageEditor(messageIndex, isNewMessage = false) {
      const conversation = this.currentConversation
      if (!conversation) return

      if (messageIndex >= 0 && messageIndex < conversation.conversations.length) {
        this.editingMessage = { ...conversation.conversations[messageIndex] }
      } else if (isNewMessage) {
        this.editingMessage = { from: 'human', value: '' }
      } else {
        return
      }

      this.messageEditor = {
        isVisible: true,
        messageIndex,
        isNewMessage
      }
    },

    // 关闭消息编辑器
    closeMessageEditor() {
      this.messageEditor = {
        isVisible: false,
        messageIndex: -1,
        isNewMessage: false
      }
      this.editingMessage = null
    },

    // 保存消息编辑
    saveMessageEdit() {
      if (!this.editingMessage) return false

      const { messageIndex, isNewMessage } = this.messageEditor
      
      if (isNewMessage) {
        this.addMessage(this.editingMessage.from, this.editingMessage.value)
      } else {
        this.updateMessage(messageIndex, this.editingMessage)
      }
      
      this.closeMessageEditor()
      return true
    },

    // 验证对话结构是否符合规则
    validateConversationStructure(messages) {
      const errors = []
      const warnings = []
      
      if (!messages || messages.length === 0) {
        return { isValid: true, errors: [], warnings: [] } // 空对话也是有效的
      }

      // 严格的 ShareGPT 格式验证规则
      this.validateRoleTypes(messages, errors)
      this.validateMessageSequence(messages, errors, warnings)
      this.validatePairings(messages, errors)
      this.validateThinkingPlacement(messages, warnings)
      this.validateContinuousMessages(messages, errors)

      return {
        isValid: errors.length === 0,
        errors,
        warnings
      }
    },

    // 验证角色类型
    validateRoleTypes(messages, errors) {
      const validRoles = ['human', 'thinking', 'function_call', 'observation', 'gpt']
      
      for (let i = 0; i < messages.length; i++) {
        const role = messages[i].from
        if (!validRoles.includes(role)) {
          errors.push(`第${i + 1}个消息: 未知的角色类型 "${role}"`)
        }
      }
    },

    // 验证消息序列和流程
    validateMessageSequence(messages, errors, warnings) {
      let expectingHuman = true // 对话应该以 human 开始
      let currentHumanIndex = -1
      let currentGptIndex = -1
      
      for (let i = 0; i < messages.length; i++) {
        const role = messages[i].from
        
        if (role === 'human') {
          if (currentHumanIndex !== -1 && currentGptIndex === -1) {
            errors.push(`第${i + 1}个消息: 检测到连续的 human 消息，第${currentHumanIndex + 1}个 human 消息缺少对应的 gpt 回复`)
          }
          currentHumanIndex = i
          currentGptIndex = -1
          expectingHuman = false
        } else if (role === 'gpt') {
          if (currentHumanIndex === -1) {
            errors.push(`第${i + 1}个消息: gpt 回复缺少对应的 human 提问`)
          }
          currentGptIndex = i
          expectingHuman = true
        }
      }
      
      // 检查是否有未完成的 human-gpt 对
      if (currentHumanIndex !== -1 && currentGptIndex === -1) {
        errors.push(`最后一个 human 消息（第${currentHumanIndex + 1}个）缺少对应的 gpt 回复`)
      }
    },

    // 验证配对关系
    validatePairings(messages, errors) {
      // 验证 function_call 和 observation 的配对
      for (let i = 0; i < messages.length; i++) {
        const role = messages[i].from
        
        if (role === 'function_call') {
          // function_call 后必须紧跟 observation
          if (i === messages.length - 1 || messages[i + 1].from !== 'observation') {
            errors.push(`第${i + 1}个消息: function_call 后必须紧跟 observation`)
          }
          
          // function_call 必须在 human-gpt 对之间
          const isInValidContext = this.isFunctionCallInValidContext(messages, i)
          if (!isInValidContext) {
            errors.push(`第${i + 1}个消息: function_call 必须在 human-gpt 对话对之间`)
          }
        } else if (role === 'observation') {
          // observation 前必须有 function_call
          if (i === 0 || messages[i - 1].from !== 'function_call') {
            errors.push(`第${i + 1}个消息: observation 前必须有 function_call`)
          }
        }
      }
    },

    // 检查 function_call 是否在有效上下文中
    isFunctionCallInValidContext(messages, index) {
      // 向前找最近的 human
      let humanIndex = -1
      for (let i = index - 1; i >= 0; i--) {
        if (messages[i].from === 'human') {
          humanIndex = i
          break
        } else if (messages[i].from === 'gpt') {
          // 如果先遇到 gpt，说明不在有效上下文中
          return false
        }
      }
      
      // 向后找对应的 gpt（在 observation 之后）
      let gptIndex = -1
      for (let i = index + 2; i < messages.length; i++) { // +2 是因为要跳过紧跟的 observation
        if (messages[i].from === 'gpt') {
          gptIndex = i
          break
        } else if (messages[i].from === 'human') {
          // 如果遇到新的 human，说明这个对话对不完整
          break
        }
      }
      
      return humanIndex !== -1 && gptIndex !== -1
    },

    // 验证 thinking 消息的位置
    validateThinkingPlacement(messages, warnings) {
      for (let i = 0; i < messages.length; i++) {
        const role = messages[i].from
        
        if (role === 'thinking') {
          // 检查 thinking 的上下文是否合理
          const isValidPlacement = this.isThinkingInValidPlacement(messages, i)
          if (!isValidPlacement) {
            warnings.push(`第${i + 1}个消息: thinking 消息的位置可能不合理，建议放在需要推理的地方`)
          }
        }
      }
    },

    // 检查 thinking 是否在合理位置
    isThinkingInValidPlacement(messages, index) {
      const prevRole = index > 0 ? messages[index - 1].from : null
      const nextRole = index < messages.length - 1 ? messages[index + 1].from : null
      
      // thinking 通常出现在以下情况：
      // 1. human 之后，gpt 回复之前
      // 2. function_call 之前（表示决定调用函数）
      // 3. observation 之后，gpt 回复之前（表示分析结果）
      
      const validPlacements = [
        prevRole === 'human' && (nextRole === 'gpt' || nextRole === 'function_call'),
        prevRole === 'human' && nextRole === 'thinking', // 允许连续的 thinking，但会有警告
        prevRole === 'observation' && nextRole === 'gpt',
        prevRole === 'observation' && nextRole === 'function_call',
        prevRole === 'observation' && nextRole === 'thinking'
      ]
      
      return validPlacements.some(Boolean)
    },

    // 验证连续消息问题
    validateContinuousMessages(messages, errors) {
      for (let i = 1; i < messages.length; i++) {
        const currentRole = messages[i].from
        const prevRole = messages[i - 1].from
        
        // 检查不允许的连续消息
        if (currentRole === prevRole) {
          switch (currentRole) {
            case 'human':
              errors.push(`第${i + 1}个消息: 检测到连续的 human 消息，需要添加 gpt 回复`)
              break
            case 'gpt':
              errors.push(`第${i + 1}个消息: 检测到连续的 gpt 消息，需要添加 human 提问`)
              break
            case 'function_call':
              errors.push(`第${i + 1}个消息: 检测到连续的 function_call 消息，中间缺少 observation`)
              break
            case 'observation':
              errors.push(`第${i + 1}个消息: 检测到连续的 observation 消息，中间缺少 function_call`)
              break
            case 'thinking':
              // thinking 可以连续，但给出警告
              break
          }
        }
        
        // 检查特殊的非法序列
        if (prevRole === 'function_call' && currentRole !== 'observation') {
          errors.push(`第${i + 1}个消息: function_call 后必须是 observation，但发现 ${currentRole}`)
        }
        
        if (prevRole === 'observation' && currentRole === 'function_call') {
          // 允许，但检查是否在有效上下文中
        }
      }
    },

    // 自动修复对话结构
    autoFixConversation() {
      const conversation = this.currentConversation
      if (!conversation) return false

      const messages = conversation.conversations
      const validation = this.validateConversationStructure(messages)
      
      if (validation.isValid) return true

      // 简单的自动修复逻辑
      let humanCount = messages.filter(m => m.from === 'human').length
      let gptCount = messages.filter(m => m.from === 'gpt').length
      
      // 如果human多于gpt，添加gpt回复
      while (humanCount > gptCount) {
        this.addMessage('gpt', '请输入AI回复...')
        gptCount++
      }
      
      // 如果gpt多于human，添加human输入
      while (gptCount > humanCount) {
        this.addMessage('human', '请输入用户问题...', 0)
        humanCount++
      }

      return true
    },

    // 获取建议的下一个角色
    getSuggestedNextRole(currentMessages = []) {
      if (currentMessages.length === 0) {
        return 'human' // 第一个消息通常是human
      }

      const context = this.analyzeConversationContext(currentMessages)
      return this.determineNextRoleFromContext(context)
    },

    // 分析对话上下文
    analyzeConversationContext(messages) {
      // 添加安全检查
      if (!messages || messages.length === 0) {
        return {
          lastRole: null,
          currentHumanIndex: -1,
          currentGptIndex: -1,
          pendingFunctionCall: false,
          isInHumanGptPair: false,
          hasCompleteCurrentPair: false
        }
      }
      
      const lastMessage = messages[messages.length - 1]
      if (!lastMessage) {
        return {
          lastRole: null,
          currentHumanIndex: -1,
          currentGptIndex: -1,
          pendingFunctionCall: false,
          isInHumanGptPair: false,
          hasCompleteCurrentPair: false
        }
      }
      
      const lastRole = lastMessage.from
      
      // 查找当前未完成的 human-gpt 对
      let currentHumanIndex = -1
      let currentGptIndex = -1
      let pendingFunctionCall = false
      
      for (let i = messages.length - 1; i >= 0; i--) {
        const message = messages[i]
        if (!message || !message.from) continue // 跳过无效消息
        
        const role = message.from
        
        if (role === 'gpt' && currentGptIndex === -1) {
          currentGptIndex = i
        } else if (role === 'human' && currentHumanIndex === -1) {
          currentHumanIndex = i
          break // 找到当前对话轮次的开始
        } else if (role === 'function_call' && currentGptIndex === -1) {
          // 有未完成的 function_call
          if (i === messages.length - 1 || (messages[i + 1] && messages[i + 1].from !== 'observation')) {
            pendingFunctionCall = true
          }
        }
      }
      
      return {
        lastRole,
        currentHumanIndex,
        currentGptIndex,
        pendingFunctionCall,
        isInHumanGptPair: currentHumanIndex !== -1 && currentGptIndex === -1,
        hasCompleteCurrentPair: currentHumanIndex !== -1 && currentGptIndex !== -1
      }
    },

    // 根据上下文确定下一个角色
    determineNextRoleFromContext(context) {
      const { lastRole, isInHumanGptPair, hasCompleteCurrentPair, pendingFunctionCall } = context
      
      // 如果没有消息，默认从human开始
      if (!lastRole) {
        return 'human'
      }
      
      // 如果有未完成的 function_call，必须是 observation
      if (pendingFunctionCall) {
        return 'observation'
      }
      
      switch (lastRole) {
        case 'human':
          // human 后优先建议 gpt，但也可以是 thinking 或 function_call
          return 'gpt'
          
        case 'thinking':
          // thinking 后可以是 gpt 或 function_call
          return isInHumanGptPair ? 'gpt' : 'function_call'
          
        case 'function_call':
          // function_call 后必须是 observation
          return 'observation'
          
        case 'observation':
          // observation 后可以继续工具调用链或回复
          return isInHumanGptPair ? 'gpt' : 'thinking'
          
        case 'gpt':
          // gpt 后开始新的对话轮次
          return 'human'
          
        default:
          return 'human'
      }
    },

    // 获取多个消息建议（重构以符合严格规范）
    getMessageSuggestions(currentMessages = []) {
      if (currentMessages.length === 0) {
        return ['human']
      }

      const context = this.analyzeConversationContext(currentMessages)
      return this.getValidNextRoles(context)
    },

    // 获取所有有效的下一个角色选项
    getValidNextRoles(context) {
      const { lastRole, isInHumanGptPair, hasCompleteCurrentPair, pendingFunctionCall } = context
      
      // 如果没有消息，默认从human开始
      if (!lastRole) {
        return ['human']
      }
      
      // 如果有未完成的 function_call，只能是 observation
      if (pendingFunctionCall) {
        return ['observation']
      }
      
      switch (lastRole) {
        case 'human':
          // human 后的有效选项：
          // - gpt（直接回复）
          // - thinking（需要思考）
          // - function_call（需要调用工具）
          return ['gpt', 'thinking', 'function_call']
          
        case 'thinking':
          // thinking 后的有效选项：
          // - gpt（完成思考，给出回复）
          // - function_call（决定调用工具）
          // - thinking（继续思考，但不推荐）
          if (isInHumanGptPair) {
            return ['gpt', 'function_call']
          } else {
            return ['gpt', 'function_call', 'thinking']
          }
          
        case 'function_call':
          // function_call 后只能是 observation
          return ['observation']
          
        case 'observation':
          // observation 后的有效选项：
          // - gpt（分析结果并回复）
          // - thinking（分析结果）
          // - function_call（继续调用其他工具）
          return ['gpt', 'thinking', 'function_call']
          
        case 'gpt':
          // gpt 后的有效选项：
          // - human（新的对话轮次）
          // - thinking（AI继续思考，少见）
          // - function_call（AI主动调用工具，少见）
          return ['human', 'thinking', 'function_call']
          
        default:
          return ['human']
      }
    },

    // 智能建议：根据上下文提供最佳建议
    getSmartSuggestions(currentMessages = []) {
      const context = this.analyzeConversationContext(currentMessages)
      const validRoles = this.getValidNextRoles(context)
      
      // 根据上下文排序建议的优先级
      const suggestions = validRoles.map(role => ({
        role,
        priority: this.calculateRolePriority(role, context),
        description: this.getRoleDescription(role, context)
      })).sort((a, b) => b.priority - a.priority)
      
      return suggestions
    },

    // 计算角色建议的优先级
    calculateRolePriority(role, context) {
      const { lastRole, isInHumanGptPair, pendingFunctionCall } = context
      
      // 基础优先级
      let priority = 50
      
      // 如果没有消息，human优先级最高
      if (!lastRole) {
        return role === 'human' ? 100 : 20
      }
      
      // 必须的后续动作优先级最高
      if (pendingFunctionCall && role === 'observation') {
        return 100
      }
      
      // 根据上下文调整优先级
      switch (lastRole) {
        case 'human':
          if (role === 'gpt') priority = 90 // 优先直接回复
          else if (role === 'thinking') priority = 70 // 需要思考时
          else if (role === 'function_call') priority = 60 // 需要工具时
          break
          
        case 'thinking':
          if (role === 'gpt') priority = 85 // 思考后回复
          else if (role === 'function_call') priority = 75 // 思考后调用工具
          break
          
        case 'observation':
          if (role === 'gpt') priority = 85 // 分析结果后回复
          else if (role === 'thinking') priority = 70 // 分析结果
          else if (role === 'function_call') priority = 60 // 继续调用工具
          break
          
        case 'gpt':
          if (role === 'human') priority = 90 // 新对话轮次
          else priority = 30 // 其他选项优先级较低
          break
      }
      
      return priority
    },

    // 组件级编辑状态管理
    setComponentEditingState(messageIndex, editingMessage) {
      this.componentEditingState.editingMessageIndex = messageIndex
      this.componentEditingState.editingMessage = editingMessage ? { ...editingMessage } : null
    },

    clearComponentEditingState() {
      this.componentEditingState.editingMessageIndex = -1
      this.componentEditingState.editingMessage = null
    },

    updateComponentEditingIndex(newIndex) {
      this.componentEditingState.editingMessageIndex = newIndex
    },

    // 自动保存编辑中的消息
    autoSaveEditingMessage() {
      const { editingMessageIndex, editingMessage } = this.componentEditingState
      
      if (editingMessageIndex >= 0 && editingMessage) {
        const datasetStore = useDatasetStore()
        const conversation = this.currentConversation
        
        if (conversation && editingMessageIndex < conversation.conversations.length) {
          try {
            conversation.conversations[editingMessageIndex] = { ...editingMessage }
            datasetStore.markAsModified()
            return true
          } catch (error) {
            console.error('自动保存消息失败:', error)
            return false
          }
        }
      }
      
      return false
    },

    // 获取角色在当前上下文中的描述
    getRoleDescription(role, context) {
      const { lastRole, isInHumanGptPair } = context
      
      // 如果没有消息，提供默认描述
      if (!lastRole) {
        return {
          'human': '开始第一个用户提问',
          'thinking': '让AI开始思考',
          'function_call': '调用工具',
          'observation': '工具执行结果',
          'gpt': 'AI回复'
        }[role] || '添加消息'
      }
      
      const descriptions = {
        'human': '开始新的用户提问',
        'thinking': lastRole === 'human' ? '让AI思考如何回应' : 
                   lastRole === 'observation' ? '分析工具执行结果' : 'AI内部思考过程',
        'function_call': lastRole === 'human' ? '直接调用工具处理' : 
                        lastRole === 'thinking' ? '执行思考后的工具调用' : '调用工具',
        'observation': '工具执行结果',
        'gpt': lastRole === 'human' ? '直接回复用户' :
               lastRole === 'thinking' ? '完成思考并回复' :
               lastRole === 'observation' ? '基于工具结果回复' : 'AI回复'
      }
      
      return descriptions[role] || '添加消息'
    }
  }
}) 